#!/usr/bin/env python3
"""
分析Base64解码后的数据
"""

import struct

def analyze_decoded_binary():
    """分析解码后的二进制数据"""
    print("🔍 === 分析Base64解码后的数据 ===\n")
    
    with open('decoded_result.bin', 'rb') as f:
        decoded_data = f.read()
    
    print(f"解码后数据长度: {len(decoded_data)} 字节")
    
    # 1. 尝试作为文本查看
    print("\n尝试作为文本查看 (忽略不可打印字符):")
    text_chars = []
    for byte in decoded_data[:200]:
        if 32 <= byte <= 126:  # 可打印ASCII
            text_chars.append(chr(byte))
        else:
            text_chars.append('.')
    print(''.join(text_chars))
    
    # 2. 查看十六进制
    print("\n十六进制视图 (前100字节):")
    hex_view = ' '.join(f'{b:02x}' for b in decoded_data[:100])
    print(hex_view)
    
    # 3. 分析字节分布
    print("\n字节值分布:")
    byte_counts = {}
    for byte in decoded_data:
        byte_counts[byte] = byte_counts.get(byte, 0) + 1
    
    # 显示最常见的字节
    sorted_bytes = sorted(byte_counts.items(), key=lambda x: x[1], reverse=True)
    print("最常见的10个字节值:")
    for byte_val, count in sorted_bytes[:10]:
        char_repr = chr(byte_val) if 32 <= byte_val <= 126 else f'\\x{byte_val:02x}'
        print(f"  0x{byte_val:02x} ({char_repr}): {count}次")
    
    # 4. 尝试XOR解密
    print("\n🔑 === 尝试对解码数据进行XOR解密 ===")
    
    # 尝试单字节XOR
    for key in range(256):
        decrypted = bytes(b ^ key for b in decoded_data[:100])
        
        # 检查是否包含JSON特征
        if b'{"' in decrypted or b'"questionText"' in decrypted:
            print(f"\n可能的XOR密钥: 0x{key:02x}")
            print(f"解密结果: {decrypted[:50]}")
            break
    
    # 5. 尝试识别是否是压缩数据
    print("\n🗜️ === 检查是否是压缩数据 ===")
    
    # 检查常见的压缩格式标志
    if decoded_data[:2] == b'\x1f\x8b':
        print("可能是GZIP压缩")
    elif decoded_data[:2] == b'PK':
        print("可能是ZIP压缩")
    elif decoded_data[:3] == b'BZh':
        print("可能是BZIP2压缩")
    else:
        print(f"未识别的格式，前4字节: {decoded_data[:4].hex()}")
    
    # 6. 尝试按结构分析
    print("\n📊 === 结构分析 ===")
    
    # 查找重复的字节序列
    pattern_len = 4
    patterns = {}
    for i in range(len(decoded_data) - pattern_len + 1):
        pattern = decoded_data[i:i+pattern_len]
        if pattern not in patterns:
            patterns[pattern] = []
        patterns[pattern].append(i)
    
    # 找出重复的模式
    repeated = {p: pos for p, pos in patterns.items() if len(pos) > 5}
    if repeated:
        print(f"重复的4字节模式 (>5次):")
        sorted_patterns = sorted(repeated.items(), key=lambda x: len(x[1]), reverse=True)
        for pattern, positions in sorted_patterns[:5]:
            hex_pattern = pattern.hex()
            print(f"  {hex_pattern}: {len(positions)}次")
    
    return decoded_data

def try_second_layer_decryption(decoded_data):
    """尝试第二层解密"""
    print("\n🔐 === 尝试第二层解密 ===")
    
    # 1. 尝试字节替换
    print("\n1. 尝试字节替换解密:")
    
    # 假设是简单的字节替换
    # 创建一个基于频率的映射
    byte_freq = {}
    for byte in decoded_data:
        byte_freq[byte] = byte_freq.get(byte, 0) + 1
    
    # JSON文本的预期字符频率
    expected_chars = b' ":,{}[]etnorsia'  # 常见字符
    
    # 按频率排序
    sorted_bytes = sorted(byte_freq.items(), key=lambda x: x[1], reverse=True)
    
    # 创建映射
    mapping = {}
    for i, (byte_val, _) in enumerate(sorted_bytes[:len(expected_chars)]):
        if i < len(expected_chars):
            mapping[byte_val] = expected_chars[i]
    
    # 解密前100字节
    decrypted = bytearray()
    for byte in decoded_data[:200]:
        if byte in mapping:
            decrypted.append(mapping[byte])
        else:
            decrypted.append(byte)
    
    print(f"结果: {bytes(decrypted[:100])}")
    
    # 2. 尝试循环XOR
    print("\n2. 尝试循环XOR解密:")
    
    # 尝试不同长度的密钥
    for key_len in [4, 8, 16]:
        # 对每个位置，找出最可能的密钥字节
        possible_key = []
        for pos in range(key_len):
            # 收集这个位置的所有字节
            bytes_at_pos = decoded_data[pos::key_len]
            
            # 尝试每个可能的密钥字节
            best_key = 0
            best_score = 0
            
            for key_byte in range(256):
                score = 0
                for b in bytes_at_pos[:20]:  # 只检查前20个
                    decrypted_byte = b ^ key_byte
                    if 32 <= decrypted_byte <= 126:  # 可打印字符
                        score += 1
                    if decrypted_byte in b'{}":,[]':  # JSON字符
                        score += 2
                
                if score > best_score:
                    best_score = score
                    best_key = key_byte
            
            possible_key.append(best_key)
        
        # 使用找到的密钥解密
        result = bytearray()
        for i, byte in enumerate(decoded_data[:100]):
            result.append(byte ^ possible_key[i % key_len])
        
        # 检查结果
        if b'{' in result or b'"' in result:
            print(f"  可能的{key_len}字节密钥: {bytes(possible_key).hex()}")
            print(f"  解密结果: {bytes(result[:50])}")

def final_attempt(decoded_data):
    """最后的尝试 - 基于已知信息"""
    print("\n🎯 === 基于已知信息的最终尝试 ===")
    
    # 我们知道这是发送到通义千问API的请求
    # 应该包含 "questionText" 等字段
    
    # 在解码数据中搜索可能的模式
    target = b"questionText"
    
    # 尝试在数据中找到这个模式的加密版本
    # 假设是简单的字节级别的替换或XOR
    
    target_len = len(target)
    
    for i in range(len(decoded_data) - target_len + 1):
        segment = decoded_data[i:i+target_len]
        
        # 计算这个段与目标的XOR
        xor_key = bytes(a ^ b for a, b in zip(segment, target))
        
        # 检查XOR密钥是否有规律（如重复）
        if len(set(xor_key)) == 1:  # 单字节XOR
            key_byte = xor_key[0]
            print(f"\n找到可能的单字节XOR密钥: 0x{key_byte:02x}")
            print(f"位置: {i}")
            
            # 解密整个数据
            decrypted = bytes(b ^ key_byte for b in decoded_data)
            if b'{"questionText"' in decrypted:
                print("✅ 解密成功!")
                with open('final_decrypted.json', 'wb') as f:
                    f.write(decrypted)
                print("解密结果已保存到 final_decrypted.json")
                return decrypted

if __name__ == "__main__":
    decoded_data = analyze_decoded_binary()
    try_second_layer_decryption(decoded_data)
    final_result = final_attempt(decoded_data)
    
    if final_result:
        print(f"\n最终解密结果预览:")
        print(final_result[:200])
    else:
        print("\n💡 需要更多信息来完成解密")
        print("建议：")
        print("1. 通过动态调试获取加密密钥")
        print("2. 分析更多的请求样本找出规律")
        print("3. 检查是否有其他加密层")